package com.imachen.ymcc.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.imachen.ymcc.constants.RedisCourseTypeConstants;
import com.imachen.ymcc.domain.CourseType;
import com.imachen.ymcc.enums.GlobalExceptionCode;
import com.imachen.ymcc.mapper.CourseTypeMapper;
import com.imachen.ymcc.service.ICourseTypeService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.imachen.ymcc.util.AssertUtil;
import com.imachen.ymcc.vo.CourseTypeCrumbsVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author imachen
 * @since 2022-09-30
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

//    @Override
//    public List<CourseType> treeData() {
//        // 查询所有的分类
//        List<CourseType> courseTypes = selectList(null);
//        // 遍历
//        List<CourseType> treeList = new ArrayList<>();
//        courseTypes.forEach(e -> {
//            if (e.getPid() != null && e.getPid().intValue() == 0){
//                // 如果等于0  就是顶级父类
//                treeList.add(e);
//            }else { // 都有父类 遍历找到各自对应的父类
//                for (CourseType parent : courseTypes) {
//                    if (parent.getId().intValue() == e.getPid().intValue()){
//                        // 如果找到了 就放入父类中的children集合
//                        parent.getChildren().add(e);
//                        // 然后结束此次循环，重新寻找下一个
//                        break;
//                    }
//
//                }
//            }
//        });
//
//        return treeList;
//    }

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;


    @Override
    @Cacheable(cacheNames = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, key = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY)
    public List<CourseType> treeData() {
//        Object redisCourseTypeTree = redisTemplate.opsForValue().get(RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES);
//        if (redisCourseTypeTree != null){
//            log.info("从缓存中查询课程分类树！");
//            return (List<CourseType>)redisCourseTypeTree;
//        }else {
//            log.info("从数据库中查询课程分类树！");
//            List<CourseType> treeData = tree();
//            redisTemplate.opsForValue().set(RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, treeData);
//            return treeData;
//        }
        return tree();
    }


    /**
     *  面包屑
     * @param courseTypeId
     * @return
     */
    @Override
    public List<CourseTypeCrumbsVo> crumbs(Long courseTypeId) {
        // 1.根据id查询类型分类数据
        CourseType courseType = selectById(courseTypeId);
        // 判断有无该类型数据
        AssertUtil.isNotNull(courseType, GlobalExceptionCode.COURSE_TYPE_IS_NULL_ERROR);
        // 2.获取path
        String path = courseType.getPath();
        AssertUtil.isNotEmpty(path, GlobalExceptionCode.COURSE_PATH_NULL_ERROR);
        // 3.将path进行分割 获取到所有的类型id
        String[] split = path.split("\\.");
        // 4.遍历split
        ArrayList<CourseTypeCrumbsVo> crumbsVos = new ArrayList<>();
        for ( String crumbsId : split) {
            // 创建vo对象
            CourseTypeCrumbsVo courseTypeCrumbsVo = new CourseTypeCrumbsVo();
            // 根据遍历的类型id得到所有类型对象
            CourseType ownerProductType = selectById(crumbsId);
            // 设置进vo对应的对象中
            courseTypeCrumbsVo.setOwnerProductType(ownerProductType);

            // 根据当前分类的父id 查询所有的同级类型id
            List<CourseType> courseTypes = selectList(
                    new EntityWrapper<CourseType>().eq("pid", ownerProductType.getPid()));
            courseTypeCrumbsVo.setOtherProductTypes(courseTypes);
            // 将分类展示数据放入到集合中
            crumbsVos.add(courseTypeCrumbsVo);
        }
        return crumbsVos;
    }


    private List<CourseType> tree() {
        // 查询所有的分类
        List<CourseType> courseTypes = selectList(null);
        // 将集合转换为map
        Map<Long, CourseType> courseTypeMap = courseTypes.stream().collect(Collectors.toMap(CourseType::getId, courseType -> courseType));
        // 遍历
        List<CourseType> treeData = new ArrayList<>();
        courseTypes.forEach(e -> {
            if (e.getPid() != null && e.getPid().intValue() == 0){
                // 如果等于0  就是顶级父类
                treeData.add(e);
            }else { // 都有父类 遍历找到各自对应的父类
                CourseType courseType = courseTypeMap.get(e.getPid());
                if (courseType != null) {
                    courseType.getChildren().add(e);
                }
            }
        });
        //redisTemplate.opsForValue().set(RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, treeData);
        return treeData;
    }


    @Override
    @CacheEvict(cacheNames = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, key = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY)
    public boolean insert(CourseType entity) {
        return super.insert(entity);
    }


    @Override
    @CacheEvict(cacheNames = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, key = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY)
    public boolean updateById(CourseType entity) {
        return super.updateById(entity);
    }


    @Override
    @CacheEvict(cacheNames = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_CACHENAMES, key = RedisCourseTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY)
    public boolean deleteById(Serializable id) {
        return super.deleteById(id);
    }
}
